// pages/booking/select-duration/index.js
const apiService = require('../../../utils/api.js');
const setting = require('../../../setting/setting.js');

Page({

	/**
	 * 页面的初始数据
	 */
	data: {
		statusBarHeight: 44, // 系统状态栏高度
		durationList: [ // 时长选项列表
			{ id: 1, duration: '5分钟', price: 2.9, selected: true },
			{ id: 2, duration: '10分钟', price: 4.9, selected: false },
			{ id: 3, duration: '20分钟', price: 9.9, selected: false },
			{ id: 4, duration: '30分钟', price: 14.9, selected: false },
			{ id: 5, duration: '40分钟', price: 19.9, selected: false },
			{ id: 6, duration: '50分钟', price: 24.9, selected: false },
			{ id: 7, duration: '60分钟', price: 29.9, selected: false }
		],
		selectedDuration: null, // 当前选中的时长对象
		// 设备相关数据
		equipmentData: null, // 从设备列表页面传来的设备数据
		// 弹窗相关
		showSuccessDialog: false, // 控制提交成功弹窗显示
		showPayDialog: false, // 控制支付弹窗显示
		showCancelDialog: false, // 控制取消弹窗显示
		showExtendConfirmDialog: false, // 控制延时确认弹窗显示
		showExtendSuccessDialog: false, // 控制延时成功弹窗显示
		// 用户数据（模拟）
		userBalance: 100 // 用户可用余额
	},

	/**
	 * 生命周期函数--监听页面加载
	 */
	onLoad(options) {
		// 获取系统信息
		this.getSystemInfo();
		
		// 处理页面参数
		this.processPageOptions(options);
		
		// 初始化默认选择
		this.initDefaultSelection();
	},

	/**
	 * 处理页面参数
	 */
	processPageOptions(options) {
		// 处理从设备列表页面传来的设备数据
		if (options.equipmentData) {
			try {
				const equipmentData = JSON.parse(decodeURIComponent(options.equipmentData));
				this.setData({ equipmentData });
				console.log('接收到设备数据：', equipmentData);
			} catch (error) {
				console.error('解析设备数据失败：', error);
			}
		}
	},

	/**
	 * 获取系统信息
	 */
	getSystemInfo() {
		const systemInfo = wx.getSystemInfoSync();
		this.setData({
			statusBarHeight: systemInfo.statusBarHeight || 44
		});
	},

	/**
	 * 初始化默认选择
	 */
	initDefaultSelection() {
		// 默认选中第一个时长选项
		const defaultSelected = this.data.durationList.find(item => item.selected);
		if (defaultSelected) {
			this.setData({
				selectedDuration: defaultSelected
			});
		}
	},

	/**
	 * 选择时长
	 */
	selectDuration(e) {
		const { index } = e.currentTarget.dataset;
		const durationList = this.data.durationList.map((item, i) => {
			return {
				...item,
				selected: i === index
			};
		});
		
		const selectedDuration = durationList[index];
		
		this.setData({
			durationList: durationList,
			selectedDuration: selectedDuration
		});

		// 触觉反馈
		wx.vibrateShort({
			type: 'light'
		});
		
		console.log('选择时长：', selectedDuration);
	},

	/**
	 * 立即开始/确认延时
	 */
	async startService() {
		if (!this.data.selectedDuration) {
			wx.showToast({
				title: '请选择使用时长',
				icon: 'none'
			});
			return;
		}

		const { equipmentData, selectedDuration } = this.data;
		
		console.log('开始服务，选择时长：', selectedDuration, '是否延时：', equipmentData?.isExtending);
		
		// 检查是否是延时操作
		if (equipmentData && equipmentData.isExtending) {
			// 延时操作：直接处理延时确认
			console.log('执行延时操作');
			await this.handleExtendConfirm();
		} else {
			// 新开始服务：直接使用默认支付方式（余额支付）
			console.log('执行新服务开始，使用余额支付');
			await this.processPayment({ method: 'balance' });
		}
	},

	/**
	 * 支付弹窗关闭事件
	 */
	onPayDialogClose() {
		console.log('支付弹窗关闭，显示取消弹窗');
		this.setData({
			showPayDialog: false,
			showCancelDialog: true
		});
	},

	/**
	 * 支付弹窗确认支付事件
	 */
	onPayDialogConfirm(e) {
		const paymentData = e.detail;
		console.log('确认支付，支付数据：', paymentData);
		
		this.setData({
			showPayDialog: false
		});
	
		// 模拟支付处理
		this.processPayment(paymentData);
	},

	/**
	 * 处理支付
	 */
	async processPayment(paymentData) {
		const { equipmentData, selectedDuration } = this.data;
		
		// 检查必要的数据
		if (!selectedDuration) {
			wx.showToast({
				title: '请选择使用时长',
				icon: 'none'
			});
			return;
		}
		
		if (!equipmentData || (!equipmentData._id && !equipmentData.id)) {
			wx.showToast({
				title: '设备信息缺失，请重新选择设备',
				icon: 'none'
			});
			return;
		}
		
		try {
			wx.showLoading({
				title: '创建订单中...'
			});

			// 解析时长（从"5分钟"格式提取数字）
			const durationMatch = selectedDuration.duration.match(/\d+/);
			const duration = durationMatch ? parseInt(durationMatch[0]) : 5;

			// 根据是否为延时操作创建不同类型的订单
			let orderResult;
			if (equipmentData.isExtending && equipmentData.currentOrderId) {
				// 创建延时订单
				orderResult = await apiService.createDeviceOrder(
					(equipmentData._id || equipmentData.id),
					duration,
					'extend',
					equipmentData.currentOrderId
				);
			} else {
				// 创建普通订单
				orderResult = await apiService.createDeviceOrder(
					(equipmentData._id || equipmentData.id),
					duration,
					'normal'
				);
			}

			if (!orderResult.success) {
				wx.hideLoading();
				wx.showToast({
					title: orderResult.message || '创建订单失败',
					icon: 'none'
				});
				return;
			}

			const orderId = orderResult.data.orderId;
			// 订单创建后，优先使用后端返回金额
			const backendAmountCent = orderResult && orderResult.data && orderResult.data.totalAmount;
			const orderAmount = backendAmountCent != null ? (backendAmountCent / 100) : selectedDuration.price; // 订单金额（优先后端）
			console.log('订单创建成功：', orderId, '金额：', orderAmount);
			this.setData({
			  payDialogAmount: orderAmount
			});

			// 后续支付流程均基于后端金额，保持原有交互不强制弹出支付弹窗
			
			// 智能支付逻辑：优先使用余额，不足时自动切换微信支付
			console.log('💳 开始支付处理，支付方式:', paymentData.method || 'balance');
			
			if (paymentData.method === 'balance' || !paymentData.method) {
				// 尝试余额支付
				console.log('💰 尝试余额支付...');
				wx.showLoading({ title: '支付中...' });
				
				const payResult = await apiService.payDeviceOrderWithBalance(orderId);
				console.log('💰 余额支付结果:', JSON.stringify(payResult, null, 2));
				
				wx.hideLoading();
				
				// 检查API调用是否成功
				if (payResult.success && payResult.data) {
					const payData = payResult.data;
					
					if (payData.success) {
						// 余额支付成功，等待后台状态更新完成
						console.log('✅ 余额支付成功，等待后台状态更新...');
						
						// 清除用户相关缓存，确保个人中心页面能获取最新余额
						const app = getApp();
						const dataManager = app.getDataManager();
						dataManager.invalidateUserCache();
						console.log('[设备订单余额支付成功] 已清除用户缓存');
						
						// 通知个人中心页面刷新数据
						const pages = getCurrentPages();
						const profilePage = pages.find(page => page.route === 'pages/main/user-profile/index');
						if (profilePage && typeof profilePage.refreshUserData === 'function') {
							console.log('[设备订单余额支付成功] 通知个人中心页面刷新数据');
							profilePage.refreshUserData();
						}
						
						// 延迟1.5秒确保后台设备状态更新完成
						setTimeout(() => {
							this.setData({
								showSuccessDialog: true
							});
							console.log('🎉 后台状态更新完成，显示成功弹窗');
						}, 1500);
						return;
					} else if (payData.needWechatPay) {
						// 余额不足，自动切换到微信支付
						console.log('⚠️ 余额不足，自动切换到微信支付');
						console.log('💳 微信支付参数:', JSON.stringify(payData.paymentParams, null, 2));
						
						// 重要：调用微信支付处理
						console.log('🚀 即将调用 processWechatPaymentWithParams');
						await this.processWechatPaymentWithParams(orderId, payData.paymentParams);
						console.log('✅ processWechatPaymentWithParams 调用完成');
						return;
					} else {
						// 其他支付错误
						console.error('❌ 余额支付失败:', payData);
						wx.showToast({
							title: payData.message || '支付失败',
							icon: 'none'
						});
						return;
					}
				} else {
					// API调用失败
					console.error('❌ API调用失败:', payResult);
					wx.showToast({
						title: payResult.message || '网络错误，请重试',
						icon: 'none'
					});
					return;
				}
			} else if (paymentData.method === 'wechat') {
				// 直接微信支付
				console.log('💳 直接微信支付');
				await this.processWechatPayment(orderId, orderAmount);
			}
		} catch (error) {
			wx.hideLoading();
			console.error('支付处理失败：', error);
			wx.showToast({
				title: '支付处理失败，请重试',
				icon: 'none'
			});
		}
	},

	/**
	 * 处理微信支付
	 */
	async processWechatPayment(orderId, orderAmount) {
		try {
			wx.showLoading({ title: '创建支付订单...' });
			
			// 准备订单数据
			const equipmentData = this.data.equipmentData;
			const selectedDuration = this.data.selectedDuration;
			
			const orderData = {
				description: `设备使用 - ${equipmentData?.name || '设备'} (${selectedDuration?.duration || '未知时长'})`,
				amount: Math.round(orderAmount * 100), // 转换为分
				out_trade_no: `device_order_${orderId}_${Date.now()}`,
				notify_url: 'https://your-domain.com/wxpay-callback' // 需要配置实际的回调URL
			};

			// 使用wxpayFunctions云函数创建支付订单
			const result = await apiService.createWxPayOrder(orderData);
			
			if (!result.success || !result.data) {
				wx.hideLoading();
				wx.showToast({
					title: result.message || '创建支付订单失败',
					icon: 'none'
				});
				return;
			}

			wx.hideLoading();
			console.log('开始微信支付，订单金额：', orderAmount);
			await this.processWechatPaymentWithParams(orderId, result.data);
		} catch (error) {
			wx.hideLoading();
			console.error('微信支付处理失败：', error);
			wx.showToast({
				title: '支付处理失败',
				icon: 'none'
			});
		}
	},

	/**
	 * 使用支付参数处理微信支付
	 */
	async processWechatPaymentWithParams(orderId, paymentParams) {
		console.log('🔄 开始处理微信支付', );
		console.log('📋 订单ID:', orderId);
		console.log('💰 支付参数:', JSON.stringify(paymentParams, null, 2));
		
		try {
			// 优先进行参数归一化，兼容不同后端返回字段
			paymentParams = apiService.normalizeWxPaymentParams(paymentParams);
			// 检查是否为测试模式（模拟器环境）
			if (paymentParams.testMode) {
				console.log('🧪 检测到测试模式，模拟支付成功');
				wx.showToast({
					title: '测试模式：支付成功',
					icon: 'success',
					duration: 2000
				});
				
				// 模拟支付成功结果
				const mockResult = {
					transactionId: `test_device_${Date.now()}`,
					payTime: Math.floor(Date.now() / 1000),
					status: 'success'
				};
				
				console.log('📞 调用支付回调接口...');
				console.log('📋 回调参数:', JSON.stringify(mockResult, null, 2));
				
				// 处理支付回调（仅云函数模式下主动调用）
				if (!setting.USE_SELF_BACKEND_PAYMENT) {
				    const callbackResult = await apiService.handleDeviceOrderPaymentCallback(orderId, mockResult);
				    
				    if (callbackResult.success) {
				        // 模拟支付成功，等待后台状态更新完成
				        console.log('✅ 模拟支付确认成功，等待后台状态更新...');
				        
				        // 延迟1.5秒确保后台设备状态更新完成
				        setTimeout(() => {
				            this.setData({
				                showSuccessDialog: true
				            });
				            console.log('🎉 后台状态更新完成，显示成功弹窗');
				        }, 1500);
				    } else {
				        console.error('❌ 支付回调失败:', callbackResult);
				        wx.showToast({
				            title: '支付确认失败',
				            icon: 'none'
				        });
				    }
				} else {
				    // 自建后端模式下，测试模式直接显示成功弹窗（无需主动回调）
				    setTimeout(() => {
				        this.setData({
				            showSuccessDialog: true
				        });
				        console.log('🎉 自建后端模式测试：显示成功弹窗');
				    }, 1500);
				}
				return;
			}
			
			// 正常微信支付流程
			console.log('📱 真机环境，调用微信支付API');
			wx.requestPayment({
				...paymentParams,
				success: async (res) => {
					console.log('✅ 微信支付成功：', res);
					// 真实支付成功后由服务端V3回调处理订单，前端不再主动调用支付回调
					console.log('ℹ️ 支付成功由服务端V3回调统一处理，前端无需主动确认回调');
					// 延迟1.5秒，等待后台设备状态更新完成后展示成功弹窗
					setTimeout(() => {
						this.setData({
							showSuccessDialog: true
						});
						console.log('🎉 后台状态更新完成，显示成功弹窗');
					}, 1500);
				},
				fail: (err) => {
					console.error('❌ 微信支付失败：', err);
					if (err.errMsg && err.errMsg.includes('cancel')) {
						console.log('⚠️ 用户取消支付');
						wx.showModal({
							title: '支付取消',
							content: '您取消了支付，设备未启动。是否重新支付？',
							success: (res) => {
								if (res.confirm) {
									console.log('🔄 用户选择重新支付');
									// 重新发起支付
									this.processWechatPaymentWithParams(orderId, paymentParams);
								} else {
									console.log('❌ 用户放弃支付');
								}
							}
						});
					} else {
						console.error('❌ 支付系统错误:', err);
						wx.showToast({
							title: '支付失败，请重试',
							icon: 'none'
						});
					}
				}
			});
		} catch (error) {
			console.error('❌ 微信支付处理异常：', error);
			wx.showToast({
				title: '支付处理失败，请重试',
				icon: 'none'
			});
		}
	},

	/**
	 * 延时确认弹窗确认事件
	 */
	onExtendConfirmDialogConfirm() {
		console.log('用户确认延时');
		this.setData({
			showExtendConfirmDialog: false
		});
		
		// 处理延时确认
		this.handleExtendConfirm();
	},

	/**
	 * 延时确认弹窗取消事件
	 */
	onExtendConfirmDialogCancel() {
		console.log('用户取消延时');
		this.setData({
			showExtendConfirmDialog: false
		});
	},

	/**
	 * 延时确认弹窗关闭事件
	 */
	onExtendConfirmDialogClose() {
		console.log('延时确认弹窗关闭');
		this.setData({
			showExtendConfirmDialog: false
		});
	},

	/**
	 * 取消弹窗保存事件
	 */
	onCancelDialogSave(e) {
		const reason = e.detail.reason;
		console.log('用户点击保存，原因：', reason);
		
		this.setData({
			showCancelDialog: false
		});
	},

	/**
	 * 取消弹窗取消事件
	 */
	onCancelDialogCancel() {
		console.log('用户点击取消');
		this.setData({
			showCancelDialog: false
		});
	},

	/**
	 * 取消弹窗关闭事件（背景关闭或程序关闭）
	 */
	onCancelDialogClose() {
		console.log('取消弹窗关闭');
		this.setData({
			showCancelDialog: false
		});
	},

	/**
	 * 显示成功弹窗
	 */
	showSuccessDialog() {
		this.setData({
			showSuccessDialog: true
		});
	},

	/**
	 * 成功弹窗关闭回调
	 */
	onDialogClose() {
		console.log('成功弹窗关闭，准备退出页面');
		this.setData({
			showSuccessDialog: false
		});
		// 弹窗关闭后退出页面
		this.exitPage();
	},

	/**
	 * 延时成功弹窗关闭回调
	 */
	onExtendSuccessDialogClose() {
		console.log('延时成功弹窗关闭，准备返回设备列表页面');
		this.setData({
			showExtendSuccessDialog: false
		});
		
		const { equipmentData, selectedDuration } = this.data;
		
		// 构造返回参数，将延时信息传递给设备列表页面
		const extendTime = parseInt(selectedDuration.duration.replace(/[^\d]/g, '')) || 30;
		
		// 通过重定向方式返回，携带延时成功参数
		wx.redirectTo({
			url: `pages/main/equipment-list/index?extendSuccess=true&equipmentId=${equipmentData._id || equipmentData.id}&extendTime=${extendTime}`,
			success: () => {
				console.log('延时成功，返回设备列表页面');
			},
			fail: (error) => {
				console.error('返回设备列表页面失败：', error);
				// 降级处理：直接返回
				this.exitPage();
			}
		});
	},


	/**
	 * 处理延时确认
	 */
	async handleExtendConfirm() {
		const { equipmentData, selectedDuration } = this.data;
		
		try {
			wx.showLoading({
				title: '创建延时订单中...'
			});

			// 解析时长（从"5分钟"格式提取数字）
			const durationMatch = selectedDuration.duration.match(/\d+/);
			const duration = durationMatch ? parseInt(durationMatch[0]) : 5;

			// 创建延时订单（需要传递原订单ID）
			const orderResult = await apiService.createDeviceOrder(
				equipmentData._id || equipmentData.id,
				duration,
				'extend',
				equipmentData.currentOrderId // 原订单ID
			);

			if (!orderResult.success) {
				wx.hideLoading();
				wx.showToast({
					title: orderResult.message || '创建延时订单失败',
					icon: 'none'
				});
				return;
			}

			const orderId = orderResult.data.orderId;
			console.log('延时订单创建成功：', orderId);

			// 使用余额支付延时订单
			wx.showLoading({ title: '支付延时费用中...' });
			
			const payResult = await apiService.payDeviceOrderWithBalance(orderId);
			
			wx.hideLoading();
			
			// 注意：apiService.callFunction 在 code===200 时会返回 success=true，需根据业务字段进一步判断
			if (payResult && payResult.success && payResult.data) {
				const payData = payResult.data;
				console.log('💰 延时余额支付结果:', JSON.stringify(payData, null, 2));
				if (payData.success) {
					// 余额支付成功，显示延时成功弹窗
					this.setData({
						showExtendSuccessDialog: true
					});
					console.log('延时支付成功');
					
					// 清除用户相关缓存，确保个人中心页面能获取最新余额
					const app = getApp();
					const dataManager = app.getDataManager();
					dataManager.invalidateUserCache();
					console.log('[设备延时订单余额支付成功] 已清除用户缓存');
					
					// 通知个人中心页面刷新数据
					const pages = getCurrentPages();
					const profilePage = pages.find(page => page.route === 'pages/main/user-profile/index');
					if (profilePage && typeof profilePage.refreshUserData === 'function') {
						console.log('[设备延时订单余额支付成功] 通知个人中心页面刷新数据');
						profilePage.refreshUserData();
					}
				} else if (payData.needWechatPay && payData.paymentParams) {
					// 余额不足，使用微信支付参数发起微信支付
					console.log('⚠️ 余额不足，切换到微信支付，参数:', JSON.stringify(payData.paymentParams, null, 2));
					await this.processWechatPaymentWithParams(orderId, payData.paymentParams);
				} else {
					// 业务失败
					wx.showToast({
						title: payData.message || '延时支付失败',
						icon: 'none'
					});
				}
			} else {
				// API调用失败或返回异常
				wx.showToast({
					title: (payResult && payResult.message) || '延时支付失败',
					icon: 'none'
				});
			}
		} catch (error) {
			wx.hideLoading();
			console.error('延时处理失败：', error);
			wx.showToast({
				title: '延时处理失败，请重试',
				icon: 'none'
			});
		}
	},

	/**
	 * 退出页面
	 */
	exitPage() {
		wx.navigateBack({
			delta: 1,
			success: () => {
				console.log('退出页面成功');
			},
			fail: (error) => {
				console.error('退出页面失败:', error);
				// 降级处理：跳转到首页
				wx.switchTab({
					url: '/pages/home/index/index'
				});
			}
		});
	},

	/**
	 * 返回上一页
	 */
	onBack() {
		wx.navigateBack({
			delta: 1,
			success: () => {
				console.log('返回上一页成功');
			},
			fail: (error) => {
				console.error('返回上一页失败:', error);
				// 降级处理：跳转到首页
				wx.switchTab({
					url: '/pages/home/index/index'
				});
			}
		});
	},

	/**
	 * 生命周期函数--监听页面初次渲染完成
	 */
	onReady() {

	},

	/**
	 * 生命周期函数--监听页面显示
	 */
	onShow() {

	},

	/**
	 * 生命周期函数--监听页面隐藏
	 */
	onHide() {

	},

	/**
	 * 生命周期函数--监听页面卸载
	 */
	onUnload() {

	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh() {

	},

	/**
	 * 页面上拉触底事件的处理函数
	 */
	onReachBottom() {

	},

	/**
	 * 用户点击右上角分享
	 */
	onShareAppMessage() {

	}
})